{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Title: #Largest Subarray Length K"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Difficulty: #Easy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Category Title: #Algorithms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tag Slug: #greedy #array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Name Translated: #贪心 #数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solution Name: largestSubarray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Translated Title: #长度为 K 的最大子数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Translated Content:\n",
    "<p>在数组&nbsp;<code>A</code>&nbsp;和数组 <code>B</code>&nbsp;中，对于第一个满足 <code>A[i] != B[i]</code>&nbsp;的索引&nbsp;<code>i</code>&nbsp;，当 <code>A[i] &gt; B[i]</code>&nbsp;时，数组 <code>A</code> 大于数组 <code>B</code>。</p>\n",
    "\n",
    "<p>例如，对于索引从 <code>0</code> 开始的数组：</p>\n",
    "\n",
    "<ul>\n",
    "\t<li><code>[1,3,2,4] &gt; [1,2,2,4]</code>&nbsp;，因为在索引&nbsp;<code>1</code>&nbsp;上，&nbsp;<code>3 &gt; 2</code>。</li>\n",
    "\t<li><code>[1,4,4,4] &lt; [2,1,1,1]</code>&nbsp;，因为在索引 <code>0</code> 上，&nbsp;<code>1 &lt; 2</code>。</li>\n",
    "</ul>\n",
    "\n",
    "<p>一个数组的子数组是原数组上的一个连续子序列。</p>\n",
    "\n",
    "<p>给定一个包含<strong>不同</strong>整数的整数类型数组&nbsp;<code>nums</code>&nbsp;，返回&nbsp;<code>nums</code>&nbsp;中长度为 <code>k</code> 的最大子数组。</p>\n",
    "\n",
    "<p>&nbsp;</p>\n",
    "\n",
    "<p><b>示例 1:</b></p>\n",
    "\n",
    "<pre>\n",
    "<strong>输入:</strong> nums = [1,4,5,2,3], k = 3\n",
    "<strong>输出:</strong> [5,2,3]\n",
    "<strong>解释:</strong> 长度为 3 的子数组有： [1,4,5]、 [4,5,2] 和 [5,2,3]。\n",
    "在这些数组中， [5,2,3] 是最大的。</pre>\n",
    "\n",
    "<p><b>示例</b><strong> 2:</strong></p>\n",
    "\n",
    "<pre>\n",
    "<strong>输入:</strong> nums = [1,4,5,2,3], k = 4\n",
    "<strong>输出:</strong> [4,5,2,3]\n",
    "<strong>解释:</strong> 长度为 4 的子数组有： [1,4,5,2] 和 [4,5,2,3]。\n",
    "在这些数组中， [4,5,2,3] 是最大的。</pre>\n",
    "\n",
    "<p><strong>示例 3:</strong></p>\n",
    "\n",
    "<pre>\n",
    "<strong>输入:</strong> nums = [1,4,5,2,3], k = 1\n",
    "<strong>输出:</strong> [5]\n",
    "</pre>\n",
    "\n",
    "<p>&nbsp;</p>\n",
    "\n",
    "<p><strong>提示：</strong></p>\n",
    "\n",
    "<ul>\n",
    "\t<li><code>1 &lt;= k &lt;= nums.length &lt;= 10<sup>5</sup></code></li>\n",
    "\t<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>\n",
    "\t<li><code>nums</code>&nbsp;中的所有整数都是<strong>不同</strong>的。</li>\n",
    "</ul>\n",
    "\n",
    "<p>&nbsp;</p>\n",
    "<b>进阶：</b>如果允许&nbsp;<code>nums</code>&nbsp;中存在相同元素，你该如何解决该问题？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Description: [largest-subarray-length-k](https://leetcode.cn/problems/largest-subarray-length-k/description/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solutions: [largest-subarray-length-k](https://leetcode.cn/problems/largest-subarray-length-k/solutions/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = ['[1,4,5,2,3]\\n3', '[1,4,5,2,3]\\n4', '[1,4,5,2,3]\\n1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        n = len(nums)\n",
    "        max_num = 0\n",
    "\n",
    "        for i in range(1,n-k+1):\n",
    "            if nums[i] > nums[max_num]:\n",
    "                max_num = i\n",
    "        return nums[max_num:(max_num+k)]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        n = len(nums)\n",
    "        index = 0\n",
    "        for i in range(1, n-k+1):\n",
    "            if nums[i] > nums[index]:\n",
    "                index = i\n",
    "        return nums[index:index+k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        n = len(nums)\n",
    "        if n == k:\n",
    "            return nums\n",
    "        max_num = 0\n",
    "        max_index = 0\n",
    "        for i in range(n-k+1):\n",
    "            if nums[i] > max_num:\n",
    "                max_num = nums[i]\n",
    "                max_index = i\n",
    "        return nums[max_index:max_index+k]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        n=len(nums)\n",
    "        max_index=nums.index(max(nums[:n-k+1]))\n",
    "        return nums[max_index:max_index+k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        max1, n = max(nums), len(nums)\n",
    "        index = nums.index(max1)\n",
    "        \n",
    "        while n - index < k:\n",
    "            index = nums.index(max(nums[:index]))\n",
    "        return nums[index: index + k]\n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        max_index=0\n",
    "        max_num=0\n",
    "        for i in range(len(nums)-k+1):\n",
    "            if nums[i]>max_num:\n",
    "                max_num=nums[i]\n",
    "                max_index=i\n",
    "        return nums[max_index:max_index+k]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        l = max(nums[:-k+1]) if k!=1 else max(nums)\n",
    "        return nums[nums.index(l):nums.index(l)+k]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        n = len(nums)\n",
    "        idx = 0\n",
    "        for i in range(1, n-k+1):\n",
    "            if nums[i]>nums[idx]:\n",
    "                idx = i \n",
    "        return nums[idx:idx+k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        return nums[nums.index(max(nums[:len(nums)-k+1])):nums.index(max(nums[:len(nums)-k+1]))+k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "from typing import List\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        # 初始化最大子数组为前k个数\n",
    "        max_sub = nums[:k]\n",
    "        # 遍历整个数组，每次与当前最大子数组进行比较\n",
    "        for i in range(1, len(nums) - k + 1):\n",
    "            # 如果找到更大的子数组，则更新 max_sub\n",
    "            if nums[i:i+k] > max_sub:\n",
    "                max_sub = nums[i:i+k]\n",
    "        return max_sub\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        max_nums = nums[0: k]\n",
    "        n = len(nums)\n",
    "        for i in range(n):\n",
    "            if nums[i] >= max_nums[0] and i + k <= n:\n",
    "                for j in range(i, i + k):\n",
    "                    if nums[j] > max_nums[j - i]:\n",
    "                        max_nums = nums[i: i + k]\n",
    "                        break\n",
    "                    elif nums[j] < max_nums[j - i]:\n",
    "                        break\n",
    "        return max_nums\n",
    "            \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        max1, n = max(nums), len(nums)\n",
    "        index = nums.index(max1)\n",
    "        \n",
    "        while n - index < k:\n",
    "            index = nums.index(max(nums[:index]))\n",
    "        return nums[index: index + k]\n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        n = len(nums)\n",
    "        max_num = 0\n",
    "\n",
    "        for i in range(1,n-k+1):\n",
    "            if nums[i] > nums[max_num]:\n",
    "                max_num = i\n",
    "        return nums[max_num:(max_num+k)]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        max1, n = max(nums), len(nums)\n",
    "        index = nums.index(max1)\n",
    "        \n",
    "        while n - index < k:\n",
    "            index = nums.index(max(nums[:index]))\n",
    "        return nums[index: index + k]\n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        idx = 0 \n",
    "        n = len(nums) \n",
    "        for i in range(n-k+1):\n",
    "            if nums[i] > nums[idx]:\n",
    "                idx = i \n",
    "        return nums[idx:idx+k]\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        max1, n = max(nums), len(nums)\n",
    "        index = nums.index(max1)\n",
    "        \n",
    "        while n - index < k:\n",
    "            index = nums.index(max(nums[:index]))\n",
    "        return nums[index: index + k]\n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        n = len(nums)\n",
    "        max_num = 0\n",
    "\n",
    "        for i in range(1,n-k+1):\n",
    "            if nums[i] > nums[max_num]:\n",
    "                max_num = i\n",
    "        return nums[max_num:(max_num+k)]\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        max_nums = nums[0: k]\n",
    "        n = len(nums)\n",
    "        for i in range(n):\n",
    "            if nums[i] > max_nums[0] and i + k <= n:\n",
    "                for j in range(i, i + k):\n",
    "                    if nums[j] > max_nums[j - i]:\n",
    "                        max_nums = nums[i: i + k]\n",
    "                        break\n",
    "                    elif nums[j] < max_nums[j - i]:\n",
    "                        break\n",
    "        return max_nums\n",
    "            \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray1(self, nums, k):\n",
    "        check_num = nums[:len(nums)-k+1]\n",
    "        max_num = max(check_num)\n",
    "        count = 0\n",
    "        res = []\n",
    "        for i in range(len(check_num)):\n",
    "            if max_num == check_num[i]:\n",
    "                count += 1\n",
    "                res.append(nums[i:i+k])\n",
    "        if count == 1:\n",
    "            idx = check_num.index(max_num)\n",
    "            return nums[idx:idx+k]\n",
    "        else:\n",
    "            tmp = res[0]\n",
    "            for v in range(1, len(res)):\n",
    "                for k in range(len(v)):\n",
    "                    if v[k] > tmp[k]:\n",
    "                        tmp = v\n",
    "                        break\n",
    "            return tmp\n",
    "\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        l = max(nums[:-k+1]) if k!=1 else max(nums)\n",
    "        return nums[nums.index(l):nums.index(l)+k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        n = len(nums)\n",
    "        t = s = 0\n",
    "        for i in range(n-k+1):\n",
    "            if nums[i] > s:\n",
    "                t = i\n",
    "                s = nums[i]\n",
    "        return nums[t:t+k]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        hnums = copy.deepcopy(nums)\n",
    "        hnums.sort()\n",
    "        n = len(nums)\n",
    "\n",
    "        for i in range(len(nums) - 1, -1, -1):\n",
    "            index = nums.index(hnums[i])\n",
    "            if n - index >= k:\n",
    "                return nums[index: index + k]\n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        max_nums = nums[0: k]\n",
    "        n = len(nums)\n",
    "        for i in range(n):\n",
    "            if nums[i] > max_nums[0] and i + k <= n:\n",
    "                for j in range(i, i + k):\n",
    "                    if nums[j] > max_nums[j - i]:\n",
    "                        max_nums = nums[i: i + k]\n",
    "                        break\n",
    "                    elif nums[j] < max_nums[j - i]:\n",
    "                        break\n",
    "        return max_nums\n",
    "            \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        return nums[nums.index(max(nums[:len(nums)-k+1])):nums.index(max(nums[:len(nums)-k+1]))+k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        max1, n = max(nums), len(nums)\n",
    "        index = nums.index(max1)\n",
    "        \n",
    "        while n - index < k:\n",
    "            index = nums.index(max(nums[:index]))\n",
    "        return nums[index: index + k]\n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        n = len(nums)\n",
    "        max_num = 0\n",
    "\n",
    "        for i in range(1,n-k+1):\n",
    "            if nums[i] > nums[max_num]:\n",
    "                max_num = i\n",
    "        return nums[max_num:(max_num+k)]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        hnums = copy.deepcopy(nums)\n",
    "        hnums.sort()\n",
    "        n = len(nums)\n",
    "\n",
    "        for i in range(len(nums) - 1, -1, -1):\n",
    "            index = nums.index(hnums[i])\n",
    "            if n - index >= k:\n",
    "                return nums[index: index + k]\n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        hnums = copy.deepcopy(nums)\n",
    "        hnums.sort()\n",
    "        n = len(nums)\n",
    "\n",
    "        for i in range(len(nums) - 1, -1, -1):\n",
    "            index = nums.index(hnums[i])\n",
    "            if n - index >= k:\n",
    "                return nums[index: index + k]\n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        hnums = copy.deepcopy(nums)\n",
    "        hnums.sort()\n",
    "        n = len(nums)\n",
    "\n",
    "        for i in range(len(nums) - 1, -1, -1):\n",
    "            index = nums.index(hnums[i])\n",
    "            if n - index >= k:\n",
    "                return nums[index: index + k]\n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        max1, n = max(nums), len(nums)\n",
    "        index = nums.index(max1)\n",
    "        \n",
    "        while n - index < k:\n",
    "            index = nums.index(max(nums[:index]))\n",
    "        return nums[index: index + k]\n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        ans = []\n",
    "        maxNum = 0\n",
    "        for i in range(len(nums) - k + 1):\n",
    "            if nums[i] > maxNum:\n",
    "                maxNum = nums[i]\n",
    "                maxId = i\n",
    "        for j in range(k):\n",
    "            ans.append(nums[maxId + j])\n",
    "        return ans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def largestSubarray(self, nums: List[int], k: int) -> List[int]:\n",
    "        ans = [0 for _ in range(k)]\n",
    "        for i in range(len(nums) - k + 1):\n",
    "            step = 0\n",
    "            for j in range(k):\n",
    "                if nums[i + step] < ans[j]:\n",
    "                    break\n",
    "                elif nums[i + step] > ans[j]:\n",
    "                    for x in range(k):\n",
    "                        ans[x] = nums[i + x]\n",
    "                    break\n",
    "                else:\n",
    "                    step += 1\n",
    "                    continue\n",
    "        return ans"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 2
}
